using System;
using System.IO;

using PickGold.Zip;

namespace PickGold.Zlib
{

	internal enum ZlibStreamFlavor { ZLIB = 1950, DEFLATE = 1951, GZIP = 1952 }

	internal class ZlibBaseStream : System.IO.Stream
	{
		protected internal ZlibCodec _z = null; // deferred init... new ZlibCodec();

		protected internal StreamMode _streamMode = StreamMode.Undefined;
		protected internal FlushType _flushMode;
		protected internal ZlibStreamFlavor _flavor;
		protected internal CompressionMode _compressionMode;
		protected internal CompressionLevel _level;
		protected internal bool _leaveOpen;
		protected internal byte[] _workingBuffer;
		protected internal int _bufferSize = ZlibConstants.WorkingBufferSizeDefault;
		protected internal byte[] _buf1 = new byte[1];

		protected internal System.IO.Stream _stream;
		protected internal CompressionStrategy Strategy = CompressionStrategy.Default;

		// workitem 7159
		private CRC32 crc;
		protected internal string _GzipFileName;
		protected internal string _GzipComment;
		protected internal DateTime _GzipMtime;
		protected internal int _gzipHeaderByteCount;

		internal int Crc32 { get { if (crc == null) return 0; return crc.Crc32Result; } }

		public ZlibBaseStream(Stream stream, CompressionMode compressionMode, CompressionLevel level, ZlibStreamFlavor flavor, bool leaveOpen)
			: base()
		{
			this._flushMode = FlushType.None;
			//this._workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT];
			this._stream = stream;
			this._leaveOpen = leaveOpen;
			this._compressionMode = compressionMode;
			this._flavor = flavor;
			this._level = level;
			// workitem 7159
			if (flavor == ZlibStreamFlavor.GZIP)
			{
				this.crc = new CRC32();
			}
		}


		protected internal bool _wantCompress
		{
			get
			{
				return (this._compressionMode == CompressionMode.Compress);
			}
		}

		private ZlibCodec z
		{
			get
			{
				if (_z == null)
				{
					bool wantRfc1950Header = (this._flavor == ZlibStreamFlavor.ZLIB);
					_z = new ZlibCodec();
					if (this._compressionMode == CompressionMode.Decompress)
					{
						_z.InitializeInflate(wantRfc1950Header);
					}
					else
					{
						_z.Strategy = Strategy;
						_z.InitializeDeflate(this._level, wantRfc1950Header);
					}
				}
				return _z;
			}
		}



		private byte[] workingBuffer
		{
			get
			{
				if (_workingBuffer == null)
					_workingBuffer = new byte[_bufferSize];
				return _workingBuffer;
			}
		}



		public override void Write(System.Byte[] buffer, int offset, int count)
		{
			// workitem 7159
			// calculate the CRC on the unccompressed data  (before writing)
			if (crc != null)
				crc.SlurpBlock(buffer, offset, count);

			if (_streamMode == StreamMode.Undefined)
				_streamMode = StreamMode.Writer;
			else if (_streamMode != StreamMode.Writer)
				throw new ZlibException("Cannot Write after Reading.");

			if (count == 0)
				return;

			// first reference of z property will initialize the private var _z
			z.InputBuffer = buffer;
			_z.NextIn = offset;
			_z.AvailableBytesIn = count;
			bool done = false;
			do
			{
				_z.OutputBuffer = workingBuffer;
				_z.NextOut = 0;
				_z.AvailableBytesOut = _workingBuffer.Length;
				int rc = (_wantCompress)
					? _z.Deflate(_flushMode)
					: _z.Inflate(_flushMode);
				if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
					throw new ZlibException((_wantCompress ? "de" : "in") + "flating: " + _z.Message);

				//if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
				_stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);

				done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;

				// If GZIP and de-compress, we're done when 8 bytes remain.
				if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
					done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);

			}
			while (!done);
		}



		private void finish()
		{
			if (_z == null) return;

			if (_streamMode == StreamMode.Writer)
			{
				bool done = false;
				do
				{
					_z.OutputBuffer = workingBuffer;
					_z.NextOut = 0;
					_z.AvailableBytesOut = _workingBuffer.Length;
					int rc = (_wantCompress)
						? _z.Deflate(FlushType.Finish)
						: _z.Inflate(FlushType.Finish);

					if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
					{
						string verb = (_wantCompress ? "de" : "in") + "flating";
						if (_z.Message == null)
							throw new ZlibException(String.Format("{0}: (rc = {1})", verb, rc));
						else
							throw new ZlibException(verb + ": " + _z.Message);
					}

					if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
					{
						_stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);
					}

					done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
					// If GZIP and de-compress, we're done when 8 bytes remain.
					if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
						done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);

				}
				while (!done);

				Flush();

				// workitem 7159
				if (_flavor == ZlibStreamFlavor.GZIP)
				{
					if (_wantCompress)
					{
						// Emit the GZIP trailer: CRC32 and  size mod 2^32
						int c1 = crc.Crc32Result;
						_stream.Write(BitConverter.GetBytes(c1), 0, 4);
						int c2 = (Int32)(crc.TotalBytesRead & 0x00000000FFFFFFFF);
						_stream.Write(BitConverter.GetBytes(c2), 0, 4);
					}
					else
					{
						throw new ZlibException("Writing with decompression is not supported.");
					}
				}
			}
			// workitem 7159
			else if (_streamMode == StreamMode.Reader)
			{
				if (_flavor == ZlibStreamFlavor.GZIP)
				{
					if (!_wantCompress)
					{
						// workitem 8501: handle edge case (decompress empty stream)
						if (_z.TotalBytesOut == 0L)
							return;

						// Read and potentially verify the GZIP trailer:
						// CRC32 and size mod 2^32
						byte[] trailer = new byte[8];

						// workitems 8679 & 12554
						if (_z.AvailableBytesIn < 8)
						{
							// Make sure we have read to the end of the stream
							Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, _z.AvailableBytesIn);
							int bytesNeeded = 8 - _z.AvailableBytesIn;
							int bytesRead = _stream.Read(trailer,
														 _z.AvailableBytesIn,
														 bytesNeeded);
							if (bytesNeeded != bytesRead)
							{
								throw new ZlibException(String.Format("Missing or incomplete GZIP trailer. Expected 8 bytes, got {0}.",
																	  _z.AvailableBytesIn + bytesRead));
							}
						}
						else
						{
							Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, trailer.Length);
						}

						Int32 crc32_expected = BitConverter.ToInt32(trailer, 0);
						Int32 crc32_actual = crc.Crc32Result;
						Int32 isize_expected = BitConverter.ToInt32(trailer, 4);
						Int32 isize_actual = (Int32)(_z.TotalBytesOut & 0x00000000FFFFFFFF);

						if (crc32_actual != crc32_expected)
							throw new ZlibException(String.Format("Bad CRC32 in GZIP trailer. (actual({0:X8})!=expected({1:X8}))", crc32_actual, crc32_expected));

						if (isize_actual != isize_expected)
							throw new ZlibException(String.Format("Bad size in GZIP trailer. (actual({0})!=expected({1}))", isize_actual, isize_expected));

					}
					else
					{
						throw new ZlibException("Reading with compression is not supported.");
					}
				}
			}
		}


		private void end()
		{
			if (z == null)
				return;
			if (_wantCompress)
			{
				_z.EndDeflate();
			}
			else
			{
				_z.EndInflate();
			}
			_z = null;
		}


		public override void Close()
		{
			if (_stream == null) return;
			try
			{
				finish();
			}
			finally
			{
				end();
				if (!_leaveOpen) _stream.Close();
				_stream = null;
			}
		}

		public override void Flush()
		{
			_stream.Flush();
		}

		public override System.Int64 Seek(System.Int64 offset, System.IO.SeekOrigin origin)
		{
			throw new NotImplementedException();
			//_outStream.Seek(offset, origin);
		}
		public override void SetLength(System.Int64 value)
		{
			_stream.SetLength(value);
		}


#if NOT
        public int Read()
        {
            if (Read(_buf1, 0, 1) == 0)
                return 0;
            // calculate CRC after reading
            if (crc!=null)
                crc.SlurpBlock(_buf1,0,1);
            return (_buf1[0] & 0xFF);
        }
#endif

		private bool nomoreinput = false;



		private string ReadZeroTerminatedString()
		{
			var list = new System.Collections.Generic.List<byte>();
			bool done = false;
			do
			{
				// workitem 7740
				int n = _stream.Read(_buf1, 0, 1);
				if (n != 1)
					throw new ZlibException("Unexpected EOF reading GZIP header.");
				else
				{
					if (_buf1[0] == 0)
						done = true;
					else
						list.Add(_buf1[0]);
				}
			} while (!done);
			byte[] a = list.ToArray();
			return GZipStream.iso8859dash1.GetString(a, 0, a.Length);
		}


		private int _ReadAndValidateGzipHeader()
		{
			int totalBytesRead = 0;
			// read the header on the first read
			byte[] header = new byte[10];
			int n = _stream.Read(header, 0, header.Length);

			// workitem 8501: handle edge case (decompress empty stream)
			if (n == 0)
				return 0;

			if (n != 10)
				throw new ZlibException("Not a valid GZIP stream.");

			if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
				throw new ZlibException("Bad GZIP header.");

			Int32 timet = BitConverter.ToInt32(header, 4);
			_GzipMtime = GZipStream._unixEpoch.AddSeconds(timet);
			totalBytesRead += n;
			if ((header[3] & 0x04) == 0x04)
			{
				// read and discard extra field
				n = _stream.Read(header, 0, 2); // 2-byte length field
				totalBytesRead += n;

				Int16 extraLength = (Int16)(header[0] + header[1] * 256);
				byte[] extra = new byte[extraLength];
				n = _stream.Read(extra, 0, extra.Length);
				if (n != extraLength)
					throw new ZlibException("Unexpected end-of-file reading GZIP header.");
				totalBytesRead += n;
			}
			if ((header[3] & 0x08) == 0x08)
				_GzipFileName = ReadZeroTerminatedString();
			if ((header[3] & 0x10) == 0x010)
				_GzipComment = ReadZeroTerminatedString();
			if ((header[3] & 0x02) == 0x02)
				Read(_buf1, 0, 1); // CRC16, ignore

			return totalBytesRead;
		}



		public override System.Int32 Read(System.Byte[] buffer, System.Int32 offset, System.Int32 count)
		{
			// According to MS documentation, any implementation of the IO.Stream.Read function must:
			// (a) throw an exception if offset & count reference an invalid part of the buffer,
			//     or if count < 0, or if buffer is null
			// (b) return 0 only upon EOF, or if count = 0
			// (c) if not EOF, then return at least 1 byte, up to <count> bytes

			if (_streamMode == StreamMode.Undefined)
			{
				if (!this._stream.CanRead) throw new ZlibException("The stream is not readable.");
				// for the first read, set up some controls.
				_streamMode = StreamMode.Reader;
				// (The first reference to _z goes through the private accessor which
				// may initialize it.)
				z.AvailableBytesIn = 0;
				if (_flavor == ZlibStreamFlavor.GZIP)
				{
					_gzipHeaderByteCount = _ReadAndValidateGzipHeader();
					// workitem 8501: handle edge case (decompress empty stream)
					if (_gzipHeaderByteCount == 0)
						return 0;
				}
			}

			if (_streamMode != StreamMode.Reader)
				throw new ZlibException("Cannot Read after Writing.");

			if (count == 0) return 0;
			if (nomoreinput && _wantCompress) return 0;  // workitem 8557
			if (buffer == null) throw new ArgumentNullException("buffer");
			if (count < 0) throw new ArgumentOutOfRangeException("count");
			if (offset < buffer.GetLowerBound(0)) throw new ArgumentOutOfRangeException("offset");
			if ((offset + count) > buffer.GetLength(0)) throw new ArgumentOutOfRangeException("count");

			int rc = 0;

			// set up the output of the deflate/inflate codec:
			_z.OutputBuffer = buffer;
			_z.NextOut = offset;
			_z.AvailableBytesOut = count;

			// This is necessary in case _workingBuffer has been resized. (new byte[])
			// (The first reference to _workingBuffer goes through the private accessor which
			// may initialize it.)
			_z.InputBuffer = workingBuffer;

			do
			{
				// need data in _workingBuffer in order to deflate/inflate.  Here, we check if we have any.
				if ((_z.AvailableBytesIn == 0) && (!nomoreinput))
				{
					// No data available, so try to Read data from the captive stream.
					_z.NextIn = 0;
					_z.AvailableBytesIn = _stream.Read(_workingBuffer, 0, _workingBuffer.Length);
					if (_z.AvailableBytesIn == 0)
						nomoreinput = true;

				}
				// we have data in InputBuffer; now compress or decompress as appropriate
				rc = (_wantCompress)
					? _z.Deflate(_flushMode)
					: _z.Inflate(_flushMode);

				if (nomoreinput && (rc == ZlibConstants.Z_BUF_ERROR))
					return 0;

				if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
					throw new ZlibException(String.Format("{0}flating:  rc={1}  msg={2}", (_wantCompress ? "de" : "in"), rc, _z.Message));

				if ((nomoreinput || rc == ZlibConstants.Z_STREAM_END) && (_z.AvailableBytesOut == count))
					break; // nothing more to read
			}
			//while (_z.AvailableBytesOut == count && rc == ZlibConstants.Z_OK);
			while (_z.AvailableBytesOut > 0 && !nomoreinput && rc == ZlibConstants.Z_OK);


			// workitem 8557
			// is there more room in output?
			if (_z.AvailableBytesOut > 0)
			{
				if (rc == ZlibConstants.Z_OK && _z.AvailableBytesIn == 0)
				{
					// deferred
				}

				// are we completely done reading?
				if (nomoreinput)
				{
					// and in compression?
					if (_wantCompress)
					{
						// no more input data available; therefore we flush to
						// try to complete the read
						rc = _z.Deflate(FlushType.Finish);

						if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
							throw new ZlibException(String.Format("Deflating:  rc={0}  msg={1}", rc, _z.Message));
					}
				}
			}


			rc = (count - _z.AvailableBytesOut);

			// calculate CRC after reading
			if (crc != null)
				crc.SlurpBlock(buffer, offset, rc);

			return rc;
		}



		public override System.Boolean CanRead
		{
			get { return this._stream.CanRead; }
		}

		public override System.Boolean CanSeek
		{
			get { return this._stream.CanSeek; }
		}

		public override System.Boolean CanWrite
		{
			get { return this._stream.CanWrite; }
		}

		public override System.Int64 Length
		{
			get { return _stream.Length; }
		}

		public override long Position
		{
			get { throw new NotImplementedException(); }
			set { throw new NotImplementedException(); }
		}

		internal enum StreamMode
		{
			Writer,
			Reader,
			Undefined,
		}


		public static void CompressString(String s, Stream compressor)
		{
			byte[] uncompressed = System.Text.Encoding.UTF8.GetBytes(s);
			using (compressor)
			{
				compressor.Write(uncompressed, 0, uncompressed.Length);
			}
		}

		public static void CompressBuffer(byte[] b, Stream compressor)
		{
			// workitem 8460
			using (compressor)
			{
				compressor.Write(b, 0, b.Length);
			}
		}

		public static String UncompressString(byte[] compressed, Stream decompressor)
		{
			// workitem 8460
			byte[] working = new byte[1024];
			var encoding = System.Text.Encoding.UTF8;
			using (var output = new MemoryStream())
			{
				using (decompressor)
				{
					int n;
					while ((n = decompressor.Read(working, 0, working.Length)) != 0)
					{
						output.Write(working, 0, n);
					}
				}

				// reset to allow read from start
				output.Seek(0, SeekOrigin.Begin);
				var sr = new StreamReader(output, encoding);
				return sr.ReadToEnd();
			}
		}

		public static byte[] UncompressBuffer(byte[] compressed, Stream decompressor)
		{
			// workitem 8460
			byte[] working = new byte[1024];
			using (var output = new MemoryStream())
			{
				using (decompressor)
				{
					int n;
					while ((n = decompressor.Read(working, 0, working.Length)) != 0)
					{
						output.Write(working, 0, n);
					}
				}
				return output.ToArray();
			}
		}

	}


}
